home *** CD-ROM | disk | FTP | other *** search
/ Collection of Tools & Utilities / Collection of Tools and Utilities.iso / c / cppmatrx.zip / MATRIX.ZIP / MATRIX.BAK next >
Text File  |  1991-02-02  |  9KB  |  386 lines
  1. #include <iostream.h>
  2. #include <stdarg.h>
  3. #include <math.h>
  4.  
  5.  
  6. typedef double matrix_t;
  7.  
  8.  
  9. class matrix {
  10.       matrix_t *matrix_data;
  11.       size_t matrix_size;
  12.  
  13.       public:
  14.          matrix (size_t matrix_length, ...);
  15.          matrix (char *dummy, size_t matrix_length,matrix_t fill_value=0.0);
  16.          matrix (matrix &m);
  17.          ~matrix (void) { delete matrix_data; }
  18.  
  19.          matrix_t get_elem (size_t row, size_t column) { return *(matrix_data + (row-1)*matrix_size + (column-1)); }
  20.          matrix_t put_elem (size_t row, size_t column, matrix_t elem) { return (*(matrix_data + (row-1)*matrix_size + (column-1)) = elem); }
  21.  
  22.          matrix_t* operator[] (size_t row) { return matrix_data + row*matrix_size; }
  23.          matrix_t& operator() (size_t row, size_t column) { return *(matrix_data + (row-1)*matrix_size + (column-1)); }
  24.          matrix operator= (matrix &m);
  25.          int operator== (matrix m);
  26.          int operator!= (matrix m);
  27.          matrix operator+ (matrix m);
  28.          matrix operator- (matrix m);
  29.          matrix operator- (void);
  30.          friend matrix_t det (matrix m);
  31.          friend matrix minor (matrix m, size_t m_row, size_t m_column);
  32.          friend void transpose (matrix &m);
  33.          friend matrix operator* (matrix m, double r);
  34.          friend matrix operator* (double r, matrix m);
  35.          friend matrix operator* (matrix m, int r);
  36.          friend matrix operator* (int r, matrix m);
  37.  
  38.  
  39.          void print_matrix (void);
  40.    };
  41.  
  42. matrix::matrix (size_t matrix_length, ...)
  43. {
  44.    va_list argptr;
  45.    size_t elem_count;
  46.  
  47.    matrix_size = matrix_length;
  48.    matrix_data = new matrix_t [matrix_size*matrix_size];
  49.  
  50.    matrix_t *i;
  51.    size_t count;
  52.  
  53.    va_start (argptr, matrix_length);
  54.  
  55.    elem_count = matrix_size*matrix_size;
  56.  
  57.    for (i = matrix_data, count = 1; count <= elem_count; i++, count++)  {
  58.          *i = (va_arg (argptr, matrix_t));
  59.       }
  60.  
  61.    va_end (argptr);
  62.  
  63.    cout << "\nCreated object Matrix\n";
  64. }
  65.  
  66. matrix::matrix (char *dummy, size_t matrix_length,matrix_t fill_value)
  67. {
  68.    size_t elem_count;
  69.  
  70.    matrix_size = matrix_length;
  71.    matrix_data = new matrix_t [matrix_size*matrix_size];
  72.  
  73.    matrix_t *i;
  74.    size_t count;
  75.  
  76.    elem_count = matrix_size*matrix_size;
  77.  
  78.    for (i = matrix_data, count = 1; count <= elem_count; count++, i++)
  79.       *i = fill_value;
  80.  
  81.    cout << "\nCreated zero matrix.\n";
  82. }
  83.  
  84. #if 0
  85.  
  86. matrix::~matrix (void)
  87. {
  88.    delete matrix_data;
  89.  
  90.    // cout << "\nDeleted object Matrix\n";
  91. }
  92. #endif
  93.  
  94. #if 0
  95.  
  96. matrix_t matrix::get_elem (size_t row, size_t column)
  97. {
  98.    
  99. }
  100.  
  101. matrix_t matrix::put_elem (size_t row, size_t column, matrix_t elem)
  102. {
  103.  
  104. }
  105.  
  106. #endif
  107.  
  108. void matrix::print_matrix (void)
  109. {
  110.    matrix_t *i;
  111.    size_t row_count, column_count;
  112.  
  113.    cout << '\n';
  114.  
  115.    for (i = matrix_data, row_count = 0, column_count = 0; row_count < matrix_size; i++)   {
  116.          cout << *i << ' ';
  117.          if (column_count == (matrix_size - 1)) {
  118.                column_count = 0;
  119.                row_count++;
  120.                cout << '\n';
  121.             }
  122.                else
  123.                   column_count++;
  124.       }
  125. }
  126. #if 0
  127.  
  128. matrix_t* matrix::operator[] (size_t row)
  129. {
  130.    // return a reference to the first element in a given row
  131.  
  132. }
  133.  
  134. matrix_t& matrix::operator() (size_t row, size_t column)
  135. {
  136.  
  137. }
  138.  
  139. #endif
  140.  
  141. matrix::matrix (matrix &m)
  142. {
  143.    matrix_t *i, *j;
  144.    size_t count, elem_count;
  145.  
  146.    matrix_size = m.matrix_size;
  147.    elem_count = matrix_size*matrix_size;
  148.  
  149.    matrix_data = new matrix_t [elem_count];
  150.  
  151.    for (i = matrix_data, j = m.matrix_data, count = 1; count <= elem_count; count++, i++, j++)
  152.       *i = *j;
  153. }
  154.  
  155. matrix matrix::operator= (matrix &m)
  156. {
  157.  
  158.    size_t elem_count;
  159.    matrix_t *i, *j;
  160.  
  161.    size_t count;
  162.  
  163.    delete matrix_data;  // erase the current contents of the matrix on the left
  164.                         // side of the assignment
  165.  
  166.    matrix_size = m.matrix_size;
  167.    elem_count = matrix_size * matrix_size;
  168.  
  169.    matrix_data = new matrix_t [elem_count];  // allocate space for the new matrix, identical to the argument
  170.  
  171.    for (i = matrix_data, j = m.matrix_data, count = 1; count <= elem_count; count++, i++, j++)
  172.       *i = *j;
  173.  
  174.    return *this;
  175. }
  176.  
  177. matrix matrix::operator+ (matrix m)
  178. {
  179.    matrix temp ("*",matrix_size);
  180.    matrix_t *i, *j, *k;
  181.    size_t counter;
  182.    size_t elem_count;
  183.  
  184.    elem_count = matrix_size * matrix_size;
  185.  
  186.    for (i = matrix_data, j = m.matrix_data, k = temp.matrix_data, counter = 1;
  187.         counter <= elem_count; i++, j++, k++, counter++)
  188.            *k = *i + *j;
  189.  
  190.    return temp;
  191. }
  192.  
  193. matrix matrix::operator- (matrix m)
  194. {
  195.    matrix temp ("*",matrix_size);
  196.    matrix_t *i, *j, *k;
  197.    size_t counter;
  198.    size_t elem_count;
  199.  
  200.    elem_count = matrix_size * matrix_size;
  201.  
  202.    for (i = matrix_data, j = m.matrix_data, k = temp.matrix_data, counter = 1;
  203.         counter <= elem_count; i++, j++, k++, counter++)
  204.            *k = *i - *j;
  205.  
  206.    return temp;
  207. }
  208.  
  209.  
  210. inline void swap (matrix_t &a, matrix_t &b)
  211. {
  212.    matrix_t temp;
  213.  
  214.    temp = a;
  215.    a = b;
  216.    b = temp;
  217. }
  218.  
  219.  
  220. void transpose (matrix &m)
  221. {
  222.    size_t i,j;
  223.  
  224.    for (i = 2; i <= m.matrix_size; i++)
  225.       for (j = 1; j <= i-1; j++)
  226.          swap (m (i,j), m (j,i));
  227. }
  228.  
  229.  
  230. matrix minor (matrix m, size_t m_row, size_t m_column)
  231. {
  232.    matrix temp ("*", m.matrix_size-1);
  233.    
  234.    for (column = 1, temp_column = 1; column <= matrix_size; column++)  {
  235.          if (column != m_column) {
  236.                for (row = 1; row <= matrix_size; row++)
  237.                   if (row != m_row) {
  238.                      temp (temp_row, temp_column) = m (row, column);
  239.                      temp_row++;
  240.                   }
  241.  
  242.                temp_column++;
  243.             }
  244.       }
  245.  
  246.    return temp;
  247. }
  248.  
  249.  
  250.  
  251. matrix_t det (matrix m)
  252. {
  253.  
  254.    int factor;
  255.  
  256.    if (m.matrix_size == 2)
  257.       return m (1,1)*m (2,2) - m (1,2)*m (2,1);
  258.          else  {
  259.                  matrix_t value = 0.0;
  260.                  size_t col;
  261.                  size_t temp_row, temp_col;
  262.                  size_t current_col;
  263.                  matrix temp ("*",m.matrix_size-1);
  264.  
  265.                  for (col = 1, factor = 1; col <= m.matrix_size; col++, factor *= (-1))   {
  266.                         for (current_col = 1, temp_col = 1; current_col <= m.matrix_size; current_col++)
  267.                            if (current_col != col)  {
  268.                               for (temp_row = 2; temp_row <= m.matrix_size; temp_row++)
  269.                                  temp (temp_row-1,temp_col) = m (temp_row,current_col);
  270.  
  271.                               temp_col++;
  272.                            }
  273.  
  274.                         value += m (1, col) * det (temp) * factor; 
  275.                     }
  276.  
  277.                  return value;
  278.             }
  279. }
  280.  
  281. int matrix::operator== (matrix m)
  282. {
  283.  
  284.    if (matrix_size == m.matrix_size)
  285.       return ! memcmp (matrix_data, m.matrix_data, matrix_size*matrix_size);
  286.          else
  287.             return 0;
  288. }
  289.  
  290.  
  291. int matrix::operator!= (matrix m)
  292. {
  293.  
  294.    if (matrix_size == m.matrix_size)
  295.       return memcmp (matrix_data, m.matrix_data, matrix_size*matrix_size);
  296.          else
  297.             return 1;
  298. }
  299.  
  300. matrix operator* (matrix m, double r)
  301. {
  302.    matrix temp ("*",m.matrix_size);
  303.    matrix_t *i, *t;
  304.    size_t count, elem_count = m.matrix_size*m.matrix_size;
  305.  
  306.    for (i = m.matrix_data, t = temp.matrix_data, count = 1; count <= elem_count; i++, t++, count++)
  307.       *t = *i * r;
  308.  
  309.    return temp;
  310. }
  311.  
  312. matrix operator* (double r, matrix m)
  313. {
  314.    matrix temp ("*",m.matrix_size);
  315.    matrix_t *i, *t;
  316.    size_t count, elem_count = m.matrix_size*m.matrix_size;
  317.  
  318.    for (i = m.matrix_data, t = temp.matrix_data, count = 1; count <= elem_count; i++, t++, count++)
  319.       *t = *i * r;
  320.  
  321.    return temp;
  322. }
  323.  
  324. matrix operator* (matrix m, int r)
  325. {
  326.    matrix temp ("*",m.matrix_size);
  327.    matrix_t *i, *t;
  328.    size_t count, elem_count = m.matrix_size*m.matrix_size;
  329.  
  330.    for (i = m.matrix_data, t = temp.matrix_data, count = 1; count <= elem_count; i++, t++, count++)
  331.       *t = *i * r;
  332.  
  333.    return temp;
  334. }
  335.  
  336. matrix operator* (int r, ma